Please address the comments from this code review:

## Overall Comments
- Add a using directive for System.Diagnostics.CodeAnalysis (or fully qualify) so that the ExcludeFromCodeCoverage attributes compile correctly.
- Consider changing MarginOptions properties from object? to a more specific type (e.g., string) to avoid boxing and improve type safety.
- Add unit tests for the PaperFormat static members to verify their predefined width/height values.

## Individual Comments

### Comment 1
<location> `src/BootstrapBlazor/Options/PaperFormat.cs:12` </location>
<code_context>
+/// 纸张规格配置类
+/// </summary>
+[ExcludeFromCodeCoverage]
+public record PaperFormat
+{
+    /// <summary>
</code_context>

<issue_to_address>
**suggestion:** Consider making PaperFormat immutable for thread safety and consistency.

Width and Height should be init-only or readonly to prevent changes after creation, ensuring immutability for this value object.
</issue_to_address>

### Comment 2
<location> `src/BootstrapBlazor/Options/MarginOptions.cs:14-32` </location>
<code_context>
+    /// <summary>
+    /// Top margin, accepts values labeled with units.
+    /// </summary>
+    public object? Top { get; set; }
+
+    /// <summary>
+    /// Left margin, accepts values labeled with units.
+    /// </summary>
+    public object? Left { get; set; }
+
+    /// <summary>
+    /// Bottom margin, accepts values labeled with units.
+    /// </summary>
+    public object? Bottom { get; set; }
+
+    /// <summary>
+    /// Right margin, accepts values labeled with units.
+    /// </summary>
+    public object? Right { get; set; }
+}
</code_context>

<issue_to_address>
**suggestion:** Using object? for margin properties may reduce type safety.

Consider specifying a more precise type for margin properties to prevent runtime issues and make the code clearer.

```suggestion
    /// <summary>
    /// Top margin, accepts values labeled with units (e.g., "10px", "2em", "5%").
    /// </summary>
    public string? Top { get; set; }

    /// <summary>
    /// Left margin, accepts values labeled with units (e.g., "10px", "2em", "5%").
    /// </summary>
    public string? Left { get; set; }

    /// <summary>
    /// Bottom margin, accepts values labeled with units (e.g., "10px", "2em", "5%").
    /// </summary>
    public string? Bottom { get; set; }

    /// <summary>
    /// Right margin, accepts values labeled with units (e.g., "10px", "2em", "5%").
    /// </summary>
    public string? Right { get; set; }
```
</issue_to_address>

### Comment 3
<location> `test/UnitTest/Options/PdfOptionsTest.cs:10-19` </location>
<code_context>
+
+public class PdfOptionsTest
+{
+    [Fact]
+    public void Test_PdfOptions_Ok()
+    {
+        var options = new PdfOptions()
+        {
+            Scale = 1.0m,
+            DisplayHeaderFooter = true,
+            PrintBackground = true,
+            Landscape = true,
+            Format = PaperFormat.A1,
+            MarginOptions = new MarginOptions()
+            {
+                Top = "10mm",
+                Bottom = "10mm",
+                Left = "10mm",
+                Right = "10mm"
+            }
+        };
+        Assert.Equal(1.0m, options.Scale);
</code_context>

<issue_to_address>
**suggestion (testing):** Missing tests for default values and edge cases in PdfOptions.

Please add tests for default property values and edge cases, such as boundary values for Scale and handling of MarginOptions when unset or null.

Suggested implementation:

```csharp
public class PdfOptionsTest
{
    [Fact]
    public void Test_PdfOptions_Ok()
    {
        var options = new PdfOptions()
        {
            Scale = 1.0m,
            DisplayHeaderFooter = true,
            PrintBackground = true,
            Landscape = true,
            Format = PaperFormat.A1,
            MarginOptions = new MarginOptions()
            {
                Top = "10mm",
                Bottom = "10mm",
                Left = "10mm",
                Right = "10mm"
            }
        };
        Assert.Equal(1.0m, options.Scale);
        Assert.True(options.DisplayHeaderFooter);
        Assert.True(options.PrintBackground);
        Assert.True(options.Landscape);
        Assert.Equal(PaperFormat.A1, options.Format);
        Assert.Equal("10mm", options.MarginOptions.Top);
        Assert.Equal("10mm", options.MarginOptions.Bottom);
        Assert.Equal("10mm", options.MarginOptions.Left);
        Assert.Equal("10mm", options.MarginOptions.Right);
    }

    [Fact]
    public void Test_PdfOptions_DefaultValues()
    {
        var options = new PdfOptions();
        Assert.Equal(1.0m, options.Scale); // Assuming default is 1.0m
        Assert.False(options.DisplayHeaderFooter); // Assuming default is false
        Assert.False(options.PrintBackground); // Assuming default is false
        Assert.False(options.Landscape); // Assuming default is false
        Assert.Equal(PaperFormat.A4, options.Format); // Assuming default is A4
        Assert.NotNull(options.MarginOptions);
        Assert.Equal("0mm", options.MarginOptions.Top); // Assuming default is "0mm"
        Assert.Equal("0mm", options.MarginOptions.Bottom);
        Assert.Equal("0mm", options.MarginOptions.Left);
        Assert.Equal("0mm", options.MarginOptions.Right);
    }

    [Theory]
    [InlineData(0.1)]
    [InlineData(2.0)]
    public void Test_PdfOptions_ScaleBoundary(decimal scale)
    {
        var options = new PdfOptions() { Scale = scale };
        Assert.Equal(scale, options.Scale);
    }

    [Fact]
    public void Test_PdfOptions_MarginOptions_Null()
    {
        var options = new PdfOptions() { MarginOptions = null };
        Assert.Null(options.MarginOptions);
    }
}

```

- If the actual default values for `PdfOptions` or `MarginOptions` differ from those assumed (e.g., Scale, Format, margin strings), adjust the assertions accordingly.
- If `MarginOptions` is not instantiated by default in `PdfOptions`, update the default value test to expect `null` instead of `NotNull`.
- If `PdfOptions` or `MarginOptions` have validation logic for boundary values, consider adding tests for invalid values and expected exceptions.
</issue_to_address>

### Comment 4
<location> `src/BootstrapBlazor/Options/PaperFormat.cs:17` </location>
<code_context>
+    /// <summary>
+    /// 
+    /// </summary>
+    public static PaperFormat Letter => new(8.5m, 11m);
+
+    /// <summary>
</code_context>

<issue_to_address>
**issue (complexity):** Consider using a centralized mapping for paper formats to avoid repetitive instantiation in each static property.

Consider centralizing the size-to-dimension mapping (once) instead of repeating `new(…,…)` in every static prop. For example, define an enum and either a switch factory or a single Dictionary:

```csharp
public enum StandardPaperFormat
{
    Letter, Legal, Tabloid, Ledger,
    A0, A1, A2, A3, A4, A5, A6
}

public record PaperFormat(decimal Width, decimal Height)
{
    private static readonly IReadOnlyDictionary<StandardPaperFormat, PaperFormat> _map
        = new Dictionary<StandardPaperFormat, PaperFormat>
    {
        [StandardPaperFormat.Letter]  = new(8.5m, 11m),
        [StandardPaperFormat.Legal]   = new(8.5m, 14m),
        [StandardPaperFormat.Tabloid] = new(11m, 17m),
        [StandardPaperFormat.Ledger]  = new(17m, 11m),
        [StandardPaperFormat.A0]      = new(33.1102m, 46.811m),
        [StandardPaperFormat.A1]      = new(23.3858m, 33.1102m),
        // …
    };

    public static PaperFormat Create(StandardPaperFormat format)
        => _map.TryGetValue(format, out var pf)
           ? pf
           : throw new ArgumentOutOfRangeException(nameof(format), format, null);
}
```

If you still want named properties for discoverability, point them at the dictionary:

```csharp
public static PaperFormat Letter  => Create(StandardPaperFormat.Letter);
public static PaperFormat Legal   => Create(StandardPaperFormat.Legal);
// …
```
</issue_to_address>